import { translateText } from './erpapi';

// 翻译缓存接口
interface TranslationCacheItem {
    translation: string; // 翻译结果
    timestamp: number;   // 缓存时间戳
}

// 翻译缓存管理器
const TRANSLATION_CACHE_KEY = 'kiki_translation_cache';
const AUTO_TRANSLATE_KEY = 'kiki_auto_translate';
const MAX_CACHE_SIZE = 2000;

// 自动翻译设置
let autoTranslateEnabled = false;

/**
 * 初始化自动翻译设置
 */
export async function initAutoTranslate(): Promise<void> {
    try {
        const result = await chrome.storage.local.get([AUTO_TRANSLATE_KEY]);
        autoTranslateEnabled = result[AUTO_TRANSLATE_KEY] || false;
        console.log('自动翻译设置已初始化:', autoTranslateEnabled);
        
        // 监听设置变更
        chrome.runtime.onMessage.addListener((message) => {
            if (message.action === 'updateAutoTranslate') {
                autoTranslateEnabled = message.value;
                console.log('自动翻译设置已更新:', autoTranslateEnabled);
                
                // 如果开启了自动翻译，立即处理当前聊天
                if (autoTranslateEnabled) {
                    handleChatChange(true);
                }
            }
        });
    } catch (error) {
        console.error('初始化自动翻译设置失败:', error);
    }
}

/**
 * 获取翻译缓存
 */
async function getTranslationCache(): Promise<Record<string, TranslationCacheItem>> {
    return new Promise((resolve) => {
        chrome.storage.local.get([TRANSLATION_CACHE_KEY], (result) => {
            resolve(result[TRANSLATION_CACHE_KEY] || {});
        });
    });
}

/**
 * 保存翻译缓存
 * @param cache 缓存对象
 */
async function saveTranslationCache(cache: Record<string, TranslationCacheItem>): Promise<void> {
    return new Promise((resolve, reject) => {
        chrome.storage.local.set({ [TRANSLATION_CACHE_KEY]: cache }, () => {
            if (chrome.runtime.lastError) {
                reject(chrome.runtime.lastError);
            } else {
                resolve();
            }
        });
    });
}

/**
 * 添加翻译结果到缓存
 * @param messageId 消息ID
 * @param translation 翻译结果
 */
async function cacheTranslation(messageId: string, translation: string): Promise<void> {
    try {
        const cache = await getTranslationCache();
        
        // 添加新的缓存项
        cache[messageId] = {
            translation,
            timestamp: Date.now()
        };
        
        // 如果缓存超过最大限制，删除最旧的项
        const cacheEntries = Object.entries(cache);
        if (cacheEntries.length > MAX_CACHE_SIZE) {
            // 按时间戳排序
            cacheEntries.sort((a, b) => a[1].timestamp - b[1].timestamp);
            
            // 创建新的缓存对象，只保留最新的MAX_CACHE_SIZE条
            const newCache: Record<string, TranslationCacheItem> = {};
            cacheEntries.slice(cacheEntries.length - MAX_CACHE_SIZE).forEach(([key, value]) => {
                newCache[key] = value;
            });
            
            await saveTranslationCache(newCache);
        } else {
            await saveTranslationCache(cache);
        }
    } catch (error) {
        console.error('缓存翻译结果出错:', error);
    }
}

/**
 * 从缓存获取翻译结果
 * @param messageId 消息ID
 * @returns 翻译结果，如果缓存中没有则返回null
 */
async function getTranslationFromCache(messageId: string): Promise<string | null> {
    try {
        if (!messageId) return null;
        
        const cache = await getTranslationCache();
        const cachedItem = cache[messageId];
        
        // 确保缓存项存在
        if (cachedItem) {
            //console.log('从缓存获取翻译结果成功:', messageId, cachedItem.translation);
            return cachedItem.translation;
        }
        
        //console.log('缓存中没有该消息的翻译结果:', messageId);
        return null;
    } catch (error) {
        //console.error('获取缓存翻译结果出错:', error);
        return null;
    }
}

/**
 * 为消息添加翻译按钮
 * @param messageRow 消息行元素
 * @param messageId 消息ID
 * @param autoTranslate 是否自动翻译
 */
export async function addTranslationButton(messageRow: Element, messageId: string, autoTranslate: boolean = false): Promise<void> {
    // 再次检查是否已经添加了翻译按钮，避免重复添加
    if (messageRow.hasAttribute('data-translation-added') || 
        messageRow.querySelector('.translate-btn') ||
        messageRow.querySelector('.translation-result')) {
        return;
    }
    
    // 标记已处理
    messageRow.setAttribute('data-translation-added', 'true');

    // 找到消息文本容器
    const textContainer = messageRow.querySelector('span.selectable-text.copyable-text');
    if (!textContainer) return;

    // 获取消息文本
    const text = textContainer.textContent || '';
    if (!text) return;

    // 获取消息容器
    const messageContainer = textContainer.closest('div._akbu');
    if (!messageContainer) return;

    // 尝试从缓存获取翻译结果
    let cachedTranslation = null;
    if (messageId) {
        //console.log('检查缓存翻译结果:', messageId);
        cachedTranslation = await getTranslationFromCache(messageId);
    }

    if (cachedTranslation) {
        // 如果有缓存的翻译结果，直接显示
        //console.log('使用缓存的翻译结果:', messageId, cachedTranslation);
        
        // 创建翻译结果容器
        const translationResult = document.createElement('div');
        translationResult.className = 'translation-result';
        translationResult.style.display = 'block';
        translationResult.style.marginTop = '4px';
        translationResult.style.color = '#667781';
        translationResult.style.fontSize = '13px';
        translationResult.textContent = cachedTranslation;
        translationResult.setAttribute('data-id', messageId);
        
        // 插入结果容器
        messageContainer.appendChild(translationResult);
    } else {
        // 创建翻译结果容器
        const translationResult = document.createElement('div');
        translationResult.className = 'translation-result';
        translationResult.style.display = 'none';
        translationResult.style.marginTop = '4px';
        translationResult.style.color = '#667781';
        translationResult.style.fontSize = '13px';
        translationResult.setAttribute('data-id', messageId);
        
        // 如果没有缓存且不是自动翻译，创建翻译按钮
        if (!autoTranslate) {
            // 创建翻译按钮
            const translateBtn = document.createElement('div');
            translateBtn.className = 'translate-btn';
            translateBtn.innerHTML = '<a href="#" style="color: #00a884; font-size: 12px; margin-top: 4px; display: inline-block;">翻译</a>';
            translateBtn.style.marginTop = '4px';
            translateBtn.setAttribute('data-id', messageId);
            
            // 插入按钮
            messageContainer.appendChild(translateBtn);
            
            // 添加点击事件
            translateBtn.onclick = async (e) => {
                e.preventDefault();
                await translateMessage(text, translationResult, translateBtn, messageId);
            };
        } else {
            // 自动翻译模式，直接翻译
            setTimeout(async () => {
                await translateMessage(text, translationResult, null, messageId);
            }, 100);
        }
        
        // 插入结果容器
        messageContainer.appendChild(translationResult);
    }
}

/**
 * 翻译消息
 * @param text 要翻译的文本
 * @param resultContainer 结果容器
 * @param translateBtn 翻译按钮
 * @param messageId 消息ID
 */
async function translateMessage(text: string, resultContainer: HTMLDivElement, translateBtn: HTMLDivElement | null, messageId: string = ''): Promise<void> {
    try {
        // 显示加载状态
        if (translateBtn) {
            translateBtn.style.display = 'none';
        }
        resultContainer.style.display = 'block';
        resultContainer.textContent = '翻译中...';
        //console.log('开始翻译消息:', messageId, text);
        
        // 尝试从缓存获取翻译结果
        let translatedText = null;
        if (messageId) {
            translatedText = await getTranslationFromCache(messageId);
            //console.log('缓存查询结果:', messageId, translatedText ? '找到缓存' : '未找到缓存');
        }
        
        // 如果缓存中没有，则调用API翻译
        if (!translatedText) {
            //console.log('调用API翻译:', text);
            translatedText = await translateText(text, 'zh', messageId);
            
            // 如果翻译成功，缓存结果
            if (translatedText && messageId) {
                //console.log('缓存翻译结果:', messageId, translatedText);
                await cacheTranslation(messageId, translatedText);
            }
        }
        
        if (translatedText) {
            //console.log('显示翻译结果:', translatedText);
            resultContainer.textContent = translatedText;
        } else {
            throw new Error('翻译结果为空');
        }
    } catch (error) {
        console.error('翻译出错:', error);
        resultContainer.textContent = '翻译失败，请重试';
        if (translateBtn) {
            translateBtn.style.display = 'inline-block';
        }
    }
}

/**
 * 处理聊天变化，为新消息添加翻译按钮
 * @param forceAutoTranslate 是否强制自动翻译
 */
export async function handleChatChange(forceAutoTranslate: boolean = false): Promise<void> {
    console.log('处理聊天变化,添加翻译按钮');
    // 获取#main下所有有data-id的div
    const messageDivs = document.querySelectorAll('#main div[data-id]');
    
    // 检查是否启用自动翻译
    const shouldAutoTranslate = forceAutoTranslate || autoTranslateEnabled;
    
    // 使用Promise.all处理所有异步操作
    await Promise.all(Array.from(messageDivs).map(async (message) => {
        // 获取消息自己的data-id
        const messageId = message.getAttribute('data-id') || '';
        
        // 检查消息是否已经添加了翻译按钮或翻译结果
        if (!message.hasAttribute('data-translation-added') && 
            !message.querySelector('.translate-btn') && 
            !message.querySelector('.translation-result')) {
            
            // console.log('为消息添加翻译按钮:', messageId);
            await addTranslationButton(message, messageId, shouldAutoTranslate);
        }
    }));
}

// 防抖函数
export function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => Promise<ReturnType<T>> {
    let timeout: NodeJS.Timeout | null = null;
    
    return (...args: Parameters<T>): Promise<ReturnType<T>> => {
        return new Promise((resolve) => {
            const later = async () => {
                timeout = null;
                const result = await func(...args);
                resolve(result);
            };
            
            if (timeout) {
                clearTimeout(timeout);
            }
            
            timeout = setTimeout(later, wait);
        });
    };
}

// 防抖处理聊天变化
export const debouncedHandleChatChange = debounce(handleChatChange, 300);

// 添加翻译样式
export function addTranslationStyles(): void {
    const style = document.createElement('style');
    style.textContent = `
        .translation-result {
            margin-top: 4px;
            color: #667781;
            font-size: 13px;
            background-color: rgba(0, 0, 0, 0.03);
            padding: 4px 8px;
            border-radius: 4px;
            white-space: pre-wrap;
        }
        
        .translate-btn a {
            color: #00a884;
            font-size: 12px;
            margin-top: 4px;
            display: inline-block;
            text-decoration: none;
        }
        
        .translate-btn a:hover {
            text-decoration: underline;
        }
    `;
    document.head.appendChild(style);
} 